const fs = require('fs');
const path = require('path');
const iconv = require('iconv-lite');

// 音标映射表（从server/utils/resourceScanner.js复制）
const phoneticMapping = {
  stress_marks: {
    5: 'ˈ'
  },
  vowels_short: {
    B: 'ɑ',
    A: 'ə',
    E: 'ə',
    a: 'æ',
    e: 'e',
    I: 'ɪ',
    i: 'ɪ',
    O: 'ɒ',
    o: 'ɒ',
    U: 'ʌ',
    u: 'ʌ'
  },
  vowels_long: {
    eI: 'eɪ',
    aI: 'aɪ',
    OI: 'ɔɪ',
    IE: 'ɪə',
    eE: 'eə',
    UE: 'ʊə',
    Ei: 'eɪ',
    Ai: 'aɪ',
    Oi: 'ɔɪ',
    EI: 'eɪ',
    AI: 'aɪ',
    OI: 'ɔɪ'
  },
  consonants: {
    b: 'b',
    c: 'k',
    d: 'd',
    f: 'f',
    g: 'g',
    h: 'h',
    j: 'dʒ',
    k: 'k',
    l: 'l',
    m: 'm',
    n: 'n',
    p: 'p',
    q: 'kw',
    r: 'r',
    s: 's',
    t: 't',
    v: 'v',
    w: 'w',
    x: 'ks',
    y: 'j',
    z: 'z'
  },
  consonant_clusters: {
    tF: 'tʃ',
    dF: 'dʒ',
    sF: 'ʃ',
    zF: 'ʒ',
    nf: 'ŋf',
    ng: 'ŋ',
    nk: 'ŋk',
    nG: 'ŋg',
    tS: 'tʃ',
    dZ: 'dʒ',
    tSH: 'tʃ',
    dZH: 'dʒ'
  },
  special: {
    F: 'ʃ',
    R: 'ɔ',
    S: 'ʃ',
    Z: 'ʒ',
    v: 'ʒ',
    V: 'ʌ',
    D: 'ð',
    T: 'θ',
    C: 'ç',
    N: 'ŋ',
    Q: 'ʌ',
    W: 'ʍ',
    J: 'ʊ',
    '^': 'ɡ',
    ':': 'ː',
    '@': 'ə',
    3: 'ɜ',
    2: 'ɑ',
    6: 'ɐ'
  },
  modifiers: {
    '(': '(',
    ')': ')',
    '[': '[',
    ']': ']',
    '{': '{',
    '}': '}'
  }
};

// 解码音标的函数
function decodePhonetic(phoneticCode) {
  if (!phoneticCode) return '';

  // 移除CDATA标记等额外内容
  let code = phoneticCode.trim();

  // Handle escaped characters - remove backslashes but keep the following character
  code = code.replace(/\\/g, '');

  // 合并所有映射，优先级：clusters > diphthongs > 其他
  const allMappings = {
    ...phoneticMapping.stress_marks,
    ...phoneticMapping.vowels_short,
    ...phoneticMapping.vowels_long,
    ...phoneticMapping.consonants,
    ...phoneticMapping.special,
    ...phoneticMapping.modifiers,
    ...phoneticMapping.consonant_clusters
  };

  // 按照优先级排序，长的键优先匹配
  const sortedMappings = Object.entries(allMappings).sort((a, b) => b[0].length - a[0].length);

  // 逐字符转换
  let result = '';
  let i = 0;
  while (i < code.length) {
    // 尝试匹配最长的键
    let matched = false;
    for (const [key, value] of sortedMappings) {
      if (code.substring(i).startsWith(key)) {
        result += value;
        i += key.length;
        matched = true;
        break;
      }
    }

    // 如果没有匹配到，保留原字符
    if (!matched) {
      result += code[i];
      i += 1;
    }
  }

  // 处理括号内的可选音素
  result = result.replace(/\(([^)]+)\)/g, '($1)');

  // 确保返回的音标以/开头和结尾
  if (!result.startsWith('/')) {
    result = '/' + result;
  }
  if (!result.endsWith('/')) {
    result = result + '/';
  }

  return result;
}

// 从dic目录随机选择指定数量的文件进行测试
function getRandomTestFiles(count = 500) {
  const dicPath = path.join(__dirname, '../resources/dic');
  const allTxtFiles = [];
  
  // 遍历所有字母目录
  const letterDirs = fs.readdirSync(dicPath).filter(item => /^[a-z]$/.test(item));
  
  for (const letter of letterDirs) {
    const letterPath = path.join(dicPath, letter);
    try {
      const files = fs.readdirSync(letterPath).filter(file => file.endsWith('.txt') && !file.includes('-pron'));
      for (const file of files) {
        allTxtFiles.push(path.join(letterPath, file));
      }
    } catch (err) {
      console.error(`无法读取目录 ${letterPath}:`, err.message);
    }
  }
  
  console.log(`总共找到 ${allTxtFiles.length} 个文件`);
  
  // 随机选择指定数量的文件
  const selectedFiles = [];
  const filesToSelect = Math.min(count, allTxtFiles.length);
  for (let i = 0; i < filesToSelect; i++) {
    const randomIndex = Math.floor(Math.random() * allTxtFiles.length);
    selectedFiles.push(allTxtFiles[randomIndex]);
    allTxtFiles.splice(randomIndex, 1);
  }
  
  return selectedFiles;
}

// 解析XML内容，提取音标编码
function extractPhoneticFromContent(content) {
  // 专门匹配词典音标标签
  const phoneticMatch = content.match(/<词典音标[^>]*>([\s\S]*?)<\/词典音标>/);
  if (phoneticMatch) {
    const innerContent = phoneticMatch[1];
    // 提取CDATA中的内容
    const cdataMatch = innerContent.match(/<!\[CDATA\[([^\]]+?)\]\]>/);
    if (cdataMatch) {
      return cdataMatch[1];
    }
  }
  
  // 尝试匹配所有类型的音标标签
  const allPhoneticMatches = content.match(/<[^>]*音标[^>]*>([\s\S]*?)<\/[^>]*音标[^>]*>/g);
  if (allPhoneticMatches) {
    for (const match of allPhoneticMatches) {
      const cdataMatch = match.match(/<!$$CDATA$$([^\]]+?)$$]]>/);
      if (cdataMatch) {
        return cdataMatch[1];
      }
    }
  }
  
  // 直接匹配包含音标编码的CDATA部分
  const phoneticMatch2 = content.match(/<!\[CDATA\[([A-Za-z0-9@:5^\]\(\)]+?)\]\]>/g);
  
  if (phoneticMatch2) {
    // 寻找看起来像音标编码的匹配项（通常较长且包含数字或特殊符号）
    for (let match of phoneticMatch2) {
      const codeMatch = match.match(/<!\[CDATA\[([A-Za-z0-9@:5^\]\(\)]+?)\]\]>/);
      if (codeMatch) {
        const code = codeMatch[1];
        // 判断是否为有效的音标编码（包含数字或特殊符号，长度适中）
        if ((/[0-9@:5^]/.test(code)) && code.length >= 3 && code.length <= 20) {
          return code;
        }
      }
    }
    
    // 如果没有找到合适的匹配，但有匹配项，则返回第一个
    if (phoneticMatch2.length > 0) {
      const firstMatch = phoneticMatch2[0].match(/<!\[CDATA\[([A-Za-z0-9@:5^\]\(\)]+?)\]\]>/);
      if (firstMatch) {
        return firstMatch[1];
      }
    }
  }
  
  return null;
}

// 主测试函数
function runTest() {
  console.log('开始测试音标映射...');
  console.log('========================');
  
  const testFiles = getRandomTestFiles(500);
  let correctMappings = 0;
  let totalMappings = 0;
  let failedMappings = 0;
  const results = [];
  
  for (const filePath of testFiles) {
    try {
      // 使用iconv-lite读取GBK编码的文件
      const buffer = fs.readFileSync(filePath);
      const content = iconv.decode(buffer, 'gbk');
      
      const phoneticCode = extractPhoneticFromContent(content);
      
      if (phoneticCode) {
        const decoded = decodePhonetic(phoneticCode);
        const fileName = path.basename(filePath, '.txt');
        
        // 存储结果用于后续分析
        results.push({
          word: fileName,
          code: phoneticCode,
          decoded: decoded
        });
        
        // 输出一些示例结果
        if (totalMappings < 20) { // 只显示前20个示例
          console.log(`${fileName}: ${phoneticCode} -> ${decoded}`);
        }
        
        totalMappings++;
      } else {
        failedMappings++;
      }
    } catch (error) {
      console.error(`处理文件时出错:`, error.message);
      failedMappings++;
    }
  }
  
  console.log('\n========================');
  console.log(`测试完成！`);
  console.log(`总共尝试处理文件数: ${testFiles.length}`);
  console.log(`成功提取音标数: ${totalMappings}`);
  console.log(`未能提取音标数: ${failedMappings}`);
  console.log(`成功率: ${(totalMappings / testFiles.length * 100).toFixed(2)}%`);
  
  // 分析结果
  if (results.length > 0) {
    console.log('\n示例转换结果:');
    console.log('========================');
    // 显示前20个结果
    results.slice(0, 20).forEach(result => {
      console.log(`${result.word}: ${result.code} -> ${result.decoded}`);
    });
    
    // 统计包含特定字符的编码
    const withSpecialChars = results.filter(r => /[5:@^]/.test(r.code)).length;
    console.log(`\n含有特殊字符的编码数量: ${withSpecialChars}/${totalMappings} (${(withSpecialChars/totalMappings*100).toFixed(2)}%)`);
    
    // 统计转换后含有特殊音标的数量
    const withIPAChars = results.filter(r => /[ˈˌæəɪʃʒðθŋɔʌʊɛɜ]/.test(r.decoded)).length;
    console.log(`转换后含有IPA音标的数量: ${withIPAChars}/${totalMappings} (${(withIPAChars/totalMappings*100).toFixed(2)}%)`);
  }
}

// 运行测试
runTest();